// A Bison parser, made by GNU Bison 3.0.4.

// Stack handling for Bison parsers in C++

// Copyright (C) 2002-2015 Free Software Foundation, Inc.

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// As a special exception, you may create a larger work that contains
// part or all of the Bison parser skeleton and distribute that work
// under terms of your choice, so long as that work isn't itself a
// parser generator using the skeleton or a modified version thereof
// as a parser skeleton.  Alternatively, if you modify or redistribute
// the parser skeleton itself, you may (at your option) remove this
// special exception, which will cause the skeleton and the resulting
// Bison output files to be licensed under the GNU General Public
// License without this special exception.

// This special exception was added by the Free Software Foundation in
// version 2.2 of Bison.

/**
 ** \file stack.hh
 ** Define the yy::stack class.
 */

#ifndef YY_YY_STACK_HH_INCLUDED
#define YY_YY_STACK_HH_INCLUDED

#include <vector>

namespace yy {
#line 46 "stack.hh" // stack.hh:132
template <class T, class S = std::vector<T>> class stack {
public:
  // Hide our reversed order.
  typedef typename S::reverse_iterator iterator;
  typedef typename S::const_reverse_iterator const_iterator;

  stack() : seq_() { seq_.reserve(200); }

  stack(unsigned int n) : seq_(n) {}

  inline T &operator[](unsigned int i) { return seq_[seq_.size() - 1 - i]; }

  inline const T &operator[](unsigned int i) const {
    return seq_[seq_.size() - 1 - i];
  }

  /// Steal the contents of \a t.
  ///
  /// Close to move-semantics.
  inline void push(T &t) {
    seq_.push_back(T());
    operator[](0).move(t);
  }

  inline void pop(unsigned int n = 1) {
    for (; n; --n)
      seq_.pop_back();
  }

  void clear() { seq_.clear(); }

  inline typename S::size_type size() const { return seq_.size(); }

  inline const_iterator begin() const { return seq_.rbegin(); }

  inline const_iterator end() const { return seq_.rend(); }

private:
  stack(const stack &);
  stack &operator=(const stack &);
  /// The wrapped container.
  S seq_;
};

/// Present a slice of the top of a stack.
template <class T, class S = stack<T>> class slice {
public:
  slice(const S &stack, unsigned int range) : stack_(stack), range_(range) {}

  inline const T &operator[](unsigned int i) const {
    return stack_[range_ - i];
  }

private:
  const S &stack_;
  unsigned int range_;
};

} // namespace yy
#line 156 "stack.hh" // stack.hh:132

#endif // !YY_YY_STACK_HH_INCLUDED
